import translationService from '../services/translationService.js'

// 全局翻译状态
let currentLanguage = 'zh'
let isTranslating = false

// 翻译指令
export const translateDirective = {
  mounted(el, binding) {
    // 保存原始文本
    if (!el._originalText) {
      el._originalText = el.textContent || binding.value || ''
    }
    
    // 添加翻译标记
    el.setAttribute('data-translate', 'true')
    
    // 如果当前不是中文，立即翻译
    if (currentLanguage !== 'zh' && el._originalText) {
      translateElement(el)
    }
  },
  
  updated(el, binding) {
    // 如果绑定值改变，更新原始文本
    if (binding.value !== binding.oldValue) {
      el._originalText = binding.value || el.textContent || ''
      
      // 如果当前不是中文，重新翻译
      if (currentLanguage !== 'zh' && el._originalText) {
        translateElement(el)
      }
    }
  },
  
  beforeUnmount(el) {
    // 清理
    el.removeAttribute('data-translate')
    delete el._originalText
  }
}

// 翻译单个元素
async function translateElement(el) {
  if (!el._originalText || currentLanguage === 'zh') {
    return
  }
  
  try {
    const translated = await translationService.translate(el._originalText, currentLanguage)
    if (translated !== el._originalText) {
      el.textContent = translated
    }
  } catch (error) {
    console.error('翻译元素失败:', error)
  }
}

// 翻译页面所有内容（包括动态内容）
export async function translatePageContent(targetLanguage = 'en') {
  if (targetLanguage === 'zh') {
    // 恢复所有原始文本
    restoreOriginalContent()
    return
  }
  
  console.log(`开始翻译页面内容到 ${targetLanguage}`)
  isTranslating = true
  
  try {
    // 方法1: 翻译所有带有data-translate属性的元素
    const markedElements = document.querySelectorAll('[data-translate="true"]')
    console.log(`找到 ${markedElements.length} 个标记的翻译元素`)
    
    for (const el of markedElements) {
      if (el._originalText) {
        await translateElement(el)
      }
    }
    
    // 方法2: 翻译所有文本节点（包括动态生成的内容）
    await translateAllTextNodes(targetLanguage)
    
    console.log('页面内容翻译完成')
  } catch (error) {
    console.error('翻译页面内容失败:', error)
  } finally {
    isTranslating = false
  }
}

// 翻译所有文本节点
async function translateAllTextNodes(targetLanguage) {
  const textNodes = []
  const walker = document.createTreeWalker(
    document.body,
    NodeFilter.SHOW_TEXT,
    {
      acceptNode: function(node) {
        // 过滤条件
        const text = node.nodeValue.trim()
        const parent = node.parentNode
        
        // 跳过空白、脚本、样式、已翻译的节点
        if (!text || 
            parent.tagName === 'SCRIPT' || 
            parent.tagName === 'STYLE' ||
            parent.hasAttribute('data-no-translate') ||
            text.length < 2) {
          return NodeFilter.FILTER_REJECT
        }
        
        // 跳过纯数字、符号
        if (/^[\d\s\-\+\*\/\=\(\)\[\]{}.,;:!?'"<>]+$/.test(text)) {
          return NodeFilter.FILTER_REJECT
        }
        
        return NodeFilter.FILTER_ACCEPT
      }
    }
  )

  let node
  while (node = walker.nextNode()) {
    textNodes.push({
      node,
      originalText: node.nodeValue.trim()
    })
  }

  console.log(`找到 ${textNodes.length} 个待翻译的文本节点`)

  // 批量翻译，限制并发数量
  const batchSize = 10
  for (let i = 0; i < textNodes.length; i += batchSize) {
    const batch = textNodes.slice(i, i + batchSize)
    const promises = batch.map(async ({ node, originalText }) => {
      try {
        const translated = await translationService.translate(originalText, targetLanguage)
        if (translated && translated !== originalText) {
          node.nodeValue = node.nodeValue.replace(originalText, translated)
        }
      } catch (error) {
        console.error('翻译文本节点失败:', originalText, error)
      }
    })
    
    await Promise.all(promises)
    
    // 添加小延迟避免API限制
    if (i + batchSize < textNodes.length) {
      await new Promise(resolve => setTimeout(resolve, 100))
    }
  }
}

// 恢复原始内容
function restoreOriginalContent() {
  const elements = document.querySelectorAll('[data-translate="true"]')
  elements.forEach(el => {
    if (el._originalText) {
      el.textContent = el._originalText
    }
  })
}

// 设置当前语言
export function setCurrentLanguage(lang) {
  currentLanguage = lang
}

// 获取翻译状态
export function getTranslationStatus() {
  return {
    currentLanguage,
    isTranslating
  }
}

// 翻译新添加的内容（用于动态内容）
export async function translateNewContent(element, targetLanguage = currentLanguage) {
  if (targetLanguage === 'zh') return
  
  // 为新元素添加翻译支持
  const textElements = element.querySelectorAll('*')
  textElements.forEach(el => {
    if (el.textContent && el.textContent.trim()) {
      el._originalText = el.textContent.trim()
      el.setAttribute('data-translate', 'true')
    }
  })
  
  // 翻译新内容
  await translatePageContent(targetLanguage)
}

export default translateDirective 